home *** CD-ROM | disk | FTP | other *** search
/ Chip: Internet / Chip Internet.iso / viewer / gsnt / source / gdevprn.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-05-26  |  11.6 KB  |  383 lines
  1. /* Copyright (C) 1990, 1992 Aladdin Enterprises.  All rights reserved.
  2.  
  3. This file is part of Ghostscript.
  4.  
  5. Ghostscript is distributed in the hope that it will be useful, but
  6. WITHOUT ANY WARRANTY.  No author or distributor accepts responsibility
  7. to anyone for the consequences of using it or for whether it serves any
  8. particular purpose or works at all, unless he says so in writing.  Refer
  9. to the Ghostscript General Public License for full details.
  10.  
  11. Everyone is granted permission to copy, modify and redistribute
  12. Ghostscript, but only under the conditions described in the Ghostscript
  13. General Public License.  A copy of this license is supposed to have been
  14. given to you along with Ghostscript so you can know your rights and
  15. responsibilities.  It should be in a file named COPYING.  Among other
  16. things, the copyright notice and this notice must be preserved on all
  17. copies.  */
  18.  
  19. /* gdevprn.c */
  20. /* Generic printer support for Ghostscript */
  21. #include "gdevprn.h"
  22. #include "gp.h"
  23. #include "gsprops.h"
  24.  
  25. /* Define the scratch file name prefix for mktemp */
  26. #define SCRATCH_TEMPLATE gp_scratch_file_name_prefix
  27.  
  28. /* Internal routine for opening a scratch file */
  29. private int
  30. open_scratch(char *fname, FILE **pfile)
  31. {    char fmode[4];
  32.     strcpy(fmode, "w+");
  33.     strcat(fmode, gp_fmode_binary_suffix);
  34.     *pfile = gp_open_scratch_file(SCRATCH_TEMPLATE, fname, fmode);
  35.     if ( *pfile == NULL )
  36.        {    eprintf1("Could not open the scratch file %s.\n", fname);
  37.         return_error(gs_error_invalidfileaccess);
  38.        }
  39.     return 0;
  40. }
  41.  
  42. /* ------ Standard device procedures ------ */
  43.  
  44. /* Macros for casting the pdev argument */
  45. #define ppdev ((gx_device_printer *)pdev)
  46. #define pmemdev ((gx_device_memory *)pdev)
  47. #define pcldev ((gx_device_clist *)pdev)
  48.  
  49. gx_device_procs prn_std_procs =
  50.   prn_procs(gdev_prn_open, gdev_prn_output_page, gdev_prn_close);
  51.  
  52. /* Generic initialization for the printer device. */
  53. /* Specific devices may wish to extend this. */
  54. int
  55. gdev_prn_open(gx_device *pdev)
  56. {    const gx_device_memory *mdev =
  57.       gdev_mem_device_for_bits(pdev->color_info.depth);
  58.     gx_device_procs *pprocs = pdev->procs;
  59.     ulong mem_space;
  60.     byte *base = 0;
  61.     char *left = 0;
  62.     if ( mdev == 0 )
  63.         return_error(gs_error_rangecheck);
  64.     memset(ppdev->skip, 0, sizeof(ppdev->skip));
  65.     ppdev->orig_procs = pprocs;
  66.     /*
  67.      * We should initialize the page count to 0, but since resetting
  68.      * some properties like page size closes and reopens the driver,
  69.      * we just have to rely on the linker initializing uninitialized
  70.      * fields to 0.  When we make page_count a property of all devices
  71.      * (which is a big deal, because many drivers currently initialize
  72.      * their structures statically and therefore can't handle changes
  73.      * in the structure), this problem will go away.  Meanwhile:
  74.      */
  75.         /* ppdev->page_count = 0; */
  76.     ppdev->file = ppdev->ccfile = ppdev->cbfile = NULL;
  77.     mem_space = gdev_mem_bitmap_size(pmemdev);
  78.     if ( mem_space >= ppdev->max_bitmap ||
  79.          mem_space != (uint)mem_space ||    /* too big to allocate */
  80.          (base = (byte *)gs_malloc((uint)mem_space, 1, "printer buffer(open)")) == 0 ||    /* can't allocate */
  81.          (PRN_MIN_MEMORY_LEFT != 0 &&
  82.           (left = gs_malloc(PRN_MIN_MEMORY_LEFT, 1, "printer memory left")) == 0)    /* not enough left */
  83.        )
  84.     {    /* Buffer the image in a command list. */
  85.         uint space;
  86.         int code;
  87.         /* Release the buffer if we allocated it. */
  88.         if ( base != 0 )
  89.             gs_free((char *)base, (uint)mem_space, 1,
  90.                 "printer buffer(open)");
  91.         for ( space = ppdev->use_buffer_space; ; )
  92.         {    base = (byte *)gs_malloc(space, 1,
  93.                          "command list buffer(open)");
  94.             if ( base != 0 ) break;
  95.             if ( (space >>= 1) < PRN_MIN_BUFFER_SPACE )
  96.                 return_error(gs_error_VMerror);    /* no hope */
  97.         }
  98. open_c:        pcldev->data = base;
  99.         pcldev->data_size = space;
  100.         pcldev->target = pdev;
  101.         pcldev->mdev = *mdev;
  102.         pcldev->mdev.target = pdev;
  103.         ppdev->buf = base;
  104.         ppdev->buffer_space = space;
  105.         /* Try opening the command list, to see if we allocated */
  106.         /* enough buffer space. */
  107.         code = (*gs_clist_device_procs.open_device)((gx_device *)pcldev);
  108.         if ( code < 0 )
  109.         {    /* If there wasn't enough room, and we haven't */
  110.             /* already shrunk the buffer, try enlarging it. */
  111.             if ( code == gs_error_limitcheck &&
  112.                  space >= ppdev->use_buffer_space
  113.                )
  114.             {    gs_free((char *)base, space, 1,
  115.                     "command list buffer(retry open)");
  116.                 space <<= 1;
  117.                 base = (byte *)gs_malloc(space, 1,
  118.                          "command list buffer(retry open)");
  119.                 ppdev->buf = base;
  120.                 if ( base != 0 ) goto open_c;
  121.             }
  122.             /* Fall through with code < 0 */
  123.         }
  124.         if ( code < 0 ||
  125.              (code = open_scratch(ppdev->ccfname, &ppdev->ccfile)) < 0 ||
  126.              (code = open_scratch(ppdev->cbfname, &ppdev->cbfile)) < 0
  127.            )
  128.         {    /* Clean up before exiting */
  129.             gdev_prn_close(pdev);
  130.             return code;
  131.         }
  132.         pcldev->cfile = ppdev->ccfile;
  133.         pcldev->bfile = ppdev->cbfile;
  134.         pcldev->bfile_end_pos = 0;
  135.         ppdev->mod_procs = gs_clist_device_procs;
  136.     }
  137.     else
  138.     {    /* Render entirely in memory. */
  139.         /* Release the leftover memory. */
  140.         gs_free(left, PRN_MIN_MEMORY_LEFT, 1,
  141.             "printer memory left");
  142.         ppdev->buffer_space = 0;
  143.         pmemdev->base = base;
  144.         ppdev->mod_procs = *mdev->procs;
  145.     }
  146.     /* Synthesize the procedure vector. */
  147.     /* Rendering operations come from the memory or clist device, */
  148.     /* non-rendering come from the printer device. */
  149.     pdev->procs = &ppdev->mod_procs;
  150. #define copy_proc(p) ppdev->mod_procs.p = pprocs->p
  151.     copy_proc(get_initial_matrix);
  152.     copy_proc(output_page);
  153.     copy_proc(close_device);
  154.     copy_proc(map_rgb_color);
  155.     copy_proc(map_color_rgb);
  156.     copy_proc(get_props);
  157.     copy_proc(put_props);
  158.     copy_proc(map_cmyk_color);
  159.     copy_proc(get_xfont_procs);
  160.     copy_proc(get_xfont_device);
  161. #undef copy_proc
  162.     return (*pdev->procs->open_device)(pdev);
  163. }
  164.  
  165. /* Added properties for printers */
  166.  
  167. private const gs_prop_item props_prn[] = {
  168.         /* Read-write properties. */
  169.     prop_def("BufferSpace", prt_int),
  170.     prop_def("MaxBitmap", prt_int),
  171.     prop_def("OutputFile", prt_string),
  172.         /* Read-only properties. */
  173.     prop_def("PageCount", prt_int)
  174. };
  175.  
  176. /* Get properties.  In addition to the standard properties, */
  177. /* we supply the max bitmap size, buffer size, and output name. */
  178. int
  179. gdev_prn_get_props(gx_device *pdev, gs_prop_item *plist)
  180. {    int start = gx_default_get_props(pdev, plist);
  181.     if ( plist != 0 )
  182.        {    register gs_prop_item *pi = plist + start;
  183.         memcpy(pi, props_prn, sizeof(props_prn));
  184.         pi[0].value.i = ppdev->use_buffer_space;
  185.         pi[1].value.i = ppdev->max_bitmap;
  186.         pi[2].value.a.p.s = ppdev->fname;
  187.         pi[2].value.a.size = -1;
  188.         pi[3].value.i = ppdev->page_count;
  189.        }
  190.     return start + sizeof(props_prn) / sizeof(gs_prop_item);
  191. }
  192.  
  193. /* Put properties. */
  194. /* Note that setting the buffer sizes closes the device. */
  195. int
  196. gdev_prn_put_props(gx_device *pdev, gs_prop_item *plist, int count)
  197. {    gs_prop_item *known[3];
  198.     int code = 0;
  199.     props_extract(plist, count, props_prn, 3, known, 0);
  200.     code = gx_default_put_props(pdev, plist, count);
  201.     if ( code < 0 ) return code;
  202.     if ( known[0] != 0 )
  203.        {    gs_prop_item *pi = known[0];
  204.         if ( pi->value.i < 10000 )
  205.             pi->status = pv_rangecheck,
  206.             code = gs_error_rangecheck;
  207.         else
  208.         {    ppdev->use_buffer_space = known[0]->value.i;
  209.             if ( code == 0 ) code = 1;
  210.         }
  211.        }
  212.     if ( known[1] != 0 )
  213.         ppdev->max_bitmap = known[1]->value.i;
  214.     if ( known[2] != 0 )
  215.        {    gs_prop_item *pn = known[2];
  216.         int size = pn->value.a.size;
  217.         if ( size >= prn_fname_sizeof )
  218.             pn->status = pv_limitcheck,
  219.             code = gs_error_limitcheck;
  220.         else
  221.            {    /* Close the file if it's open. */
  222.             if ( ppdev->file != NULL && ppdev->file != stdout )
  223.                 gp_close_printer(ppdev->file, ppdev->fname);
  224.             ppdev->file = NULL;
  225.             memcpy(ppdev->fname, pn->value.a.p.s, size);
  226.             ppdev->fname[size] = 0;
  227.             if ( code == 0 ) code = 1;
  228.            }
  229.        }
  230.     if ( code < 0 )
  231.         return_error(code);
  232.     /* If we're changing the buffer sizes, close the device; */
  233.     /* gs_putdeviceprops will reopen it. */
  234.     if ( pdev->is_open && code )
  235.     {    int ccode = gs_closedevice(pdev);
  236.         if ( ccode < 0 ) return ccode;
  237.     }
  238.     return code;
  239. }
  240.  
  241. /* Generic routine to send the page to the printer. */
  242. /****** Note that num_copies is currently ignored: this is wrong. ******/
  243. int
  244. gdev_prn_output_page(gx_device *pdev, int num_copies, int flush)
  245. {    int code, outcode, closecode;
  246.  
  247.     ppdev->page_count++;
  248.     code = gdev_prn_open_printer(pdev, 1);
  249.     if ( code < 0 ) return code;
  250.  
  251.     /* Print the accumulated page description. */
  252.     outcode = (*ppdev->print_page)(ppdev, ppdev->file);
  253.     if ( code < 0 ) return code;
  254.  
  255.     closecode = gdev_prn_close_printer(pdev);
  256.     if ( code < 0 ) return code;
  257.  
  258.     if ( ppdev->buffer_space ) /* reinitialize clist for writing */
  259.       code = (*gs_clist_device_procs.output_page)(pdev, num_copies, flush);
  260.  
  261.     if ( outcode < 0 ) return outcode;
  262.     if ( closecode < 0 ) return closecode;
  263.     return code;
  264. }
  265.  
  266. /* Generic closing for the printer device. */
  267. /* Specific devices may wish to extend this. */
  268. int
  269. gdev_prn_close(gx_device *pdev)
  270. {    if ( ppdev->ccfile != NULL )
  271.     {    fclose(ppdev->ccfile);
  272.         ppdev->ccfile = NULL;
  273.         unlink(ppdev->ccfname);
  274.     }
  275.     if ( ppdev->cbfile != NULL )
  276.     {    fclose(ppdev->cbfile);
  277.         ppdev->cbfile = NULL;
  278.         unlink(ppdev->cbfname);
  279.     }
  280.     if ( ppdev->buffer_space != 0 )
  281.     {    /* Free the buffer */
  282.         gs_free((char *)ppdev->buf, (uint)ppdev->buffer_space, 1,
  283.             "command list buffer(close)");
  284.     }
  285.     else
  286.     {    /* Free the memory device bitmap */
  287.         gs_free((char *)pmemdev->base,
  288.             (uint)gdev_mem_bitmap_size(pmemdev),
  289.             1, "printer buffer(close)");
  290.     }
  291.     if ( ppdev->file != NULL )
  292.     {    if ( ppdev->file != stdout )
  293.            gp_close_printer(ppdev->file, ppdev->fname);
  294.         ppdev->file = NULL;
  295.     }
  296.     pdev->procs = ppdev->orig_procs;
  297.     return 0;
  298. }
  299.  
  300. /* Map colors.  This is different from the default, because */
  301. /* printers write black, not white. */
  302.  
  303. gx_color_index
  304. gdev_prn_map_rgb_color(gx_device *dev, gx_color_value r, gx_color_value g,
  305.   gx_color_value b)
  306. {    /* Map values >= 1/2 to 0, < 1/2 to 1. */
  307.     return ((r | g | b) > gx_max_color_value / 2 ?
  308.         (gx_color_index)0 : (gx_color_index)1);
  309. }
  310.  
  311. int
  312. gdev_prn_map_color_rgb(gx_device *dev, gx_color_index color,
  313.   gx_color_value prgb[3])
  314. {    /* Map 0 to max_value, 1 to 0. */
  315.     prgb[0] = prgb[1] = prgb[2] = -((gx_color_value)color ^ 1);
  316.     return 0;
  317. }
  318.  
  319. /* ------ Driver services ------ */
  320.  
  321. /* Open the current page for printing. */
  322. int
  323. gdev_prn_open_printer(gx_device *pdev, int binary_mode)
  324. {    char *fname = ppdev->fname;
  325.     char pfname[prn_fname_sizeof + 10];
  326.     if ( strchr(fname, '%') )
  327.     {    sprintf(pfname, fname, ppdev->page_count);
  328.         fname = pfname;
  329.     }
  330.     if ( ppdev->file == NULL )
  331.     {    if ( !strcmp(fname, "-") )
  332.             ppdev->file = stdout;
  333.         else
  334.         {    ppdev->file = gp_open_printer(fname, binary_mode);
  335.             if ( ppdev->file == NULL )
  336.                 return_error(gs_error_invalidfileaccess);
  337.         }
  338.         ppdev->file_is_new = 1;
  339.     }
  340.     else
  341.         ppdev->file_is_new = 0;
  342.     return 0;
  343. }
  344.  
  345. /* Copy a scan line from the buffer to the printer. */
  346. int
  347. gdev_prn_get_bits(gx_device_printer *pdev, int y, byte *str, byte **actual_data)
  348. {    int code = (*pdev->procs->get_bits)((gx_device *)pdev, y, str, actual_data);
  349.     uint line_size = gdev_prn_raster(pdev);
  350.     int last_bits = -(pdev->width * pdev->color_info.depth) & 7;
  351.     if ( code < 0 ) return code;
  352.     if ( last_bits != 0 )
  353.     {    byte *dest = (actual_data != 0 ? *actual_data : str);
  354.         dest[line_size - 1] &= 0xff << last_bits;
  355.     }
  356.     return 0;
  357. }
  358. /* Copy scan lines to a buffer.  Return the number of scan lines, */
  359. /* or <0 if error. */
  360. int
  361. gdev_prn_copy_scan_lines(gx_device_printer *pdev, int y, byte *str, uint size)
  362. {    uint line_size = gdev_prn_raster(pdev);
  363.     int count = size / line_size;
  364.     int i;
  365.     byte *dest = str;
  366.     count = min(count, pdev->height - y);
  367.     for ( i = 0; i < count; i++, dest += line_size )
  368.     {    int code = gdev_prn_get_bits(pdev, y + i, dest, NULL);
  369.         if ( code < 0 ) return code;
  370.     }
  371.     return count;
  372. }
  373.  
  374. /* Close the current page. */
  375. int
  376. gdev_prn_close_printer(gx_device *pdev)
  377. {    if ( strchr(ppdev->fname, '%') )    /* file per page */
  378.        {    gp_close_printer(ppdev->file, ppdev->fname);
  379.         ppdev->file = NULL;
  380.        }
  381.     return 0;
  382. }
  383.